package com.cencat.user.enums;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 角色状态枚举
 * @author cencat
 * @since 2024-01-01
 */
@Getter
@AllArgsConstructor
public enum RoleStatus {

    /**
     * 激活状态
     */
    ACTIVE("ACTIVE", "激活", "角色处于正常激活状态，可以正常使用"),

    /**
     * 禁用状态
     */
    DISABLED("DISABLED", "禁用", "角色被禁用，无法使用相关功能"),

    /**
     * 锁定状态
     */
    LOCKED("LOCKED", "锁定", "角色被锁定，暂时无法使用"),

    /**
     * 过期状态
     */
    EXPIRED("EXPIRED", "过期", "角色已过期，需要重新激活"),

    /**
     * 待审核状态
     */
    PENDING("PENDING", "待审核", "角色待审核，审核通过后可使用"),

    /**
     * 审核拒绝状态
     */
    REJECTED("REJECTED", "审核拒绝", "角色审核被拒绝，需要重新申请"),

    /**
     * 草稿状态
     */
    DRAFT("DRAFT", "草稿", "角色处于草稿状态，尚未提交审核"),

    /**
     * 归档状态
     */
    ARCHIVED("ARCHIVED", "归档", "角色已归档，不再使用但保留记录");

    /**
     * 状态代码
     */
    private final String code;

    /**
     * 状态名称
     */
    private final String name;

    /**
     * 状态描述
     */
    private final String description;

    /**
     * 根据代码获取枚举
     * @param code 状态代码
     * @return 角色状态枚举
     */
    public static RoleStatus fromCode(String code) {
        if (code == null || code.trim().isEmpty()) {
            return null;
        }
        
        for (RoleStatus status : RoleStatus.values()) {
            if (status.getCode().equalsIgnoreCase(code.trim())) {
                return status;
            }
        }
        
        throw new IllegalArgumentException("未知的角色状态代码: " + code);
    }

    /**
     * 根据名称获取枚举
     * @param name 状态名称
     * @return 角色状态枚举
     */
    public static RoleStatus fromName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return null;
        }
        
        for (RoleStatus status : RoleStatus.values()) {
            if (status.getName().equals(name.trim())) {
                return status;
            }
        }
        
        throw new IllegalArgumentException("未知的角色状态名称: " + name);
    }

    /**
     * 检查代码是否有效
     * @param code 状态代码
     * @return 是否有效
     */
    public static boolean isValid(String code) {
        try {
            return fromCode(code) != null;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    /**
     * 检查名称是否有效
     * @param name 状态名称
     * @return 是否有效
     */
    public static boolean isValidName(String name) {
        try {
            return fromName(name) != null;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    /**
     * 获取所有状态代码
     * @return 状态代码数组
     */
    public static String[] getAllCodes() {
        RoleStatus[] statuses = RoleStatus.values();
        String[] codes = new String[statuses.length];
        for (int i = 0; i < statuses.length; i++) {
            codes[i] = statuses[i].getCode();
        }
        return codes;
    }

    /**
     * 获取所有状态名称
     * @return 状态名称数组
     */
    public static String[] getAllNames() {
        RoleStatus[] statuses = RoleStatus.values();
        String[] names = new String[statuses.length];
        for (int i = 0; i < statuses.length; i++) {
            names[i] = statuses[i].getName();
        }
        return names;
    }

    /**
     * 获取激活状态列表
     * @return 激活状态数组
     */
    public static RoleStatus[] getActiveStatuses() {
        return new RoleStatus[]{ACTIVE};
    }

    /**
     * 获取非激活状态列表
     * @return 非激活状态数组
     */
    public static RoleStatus[] getInactiveStatuses() {
        return new RoleStatus[]{DISABLED, LOCKED, EXPIRED, PENDING, REJECTED, DRAFT, ARCHIVED};
    }

    /**
     * 获取可用状态列表（可以正常使用的状态）
     * @return 可用状态数组
     */
    public static RoleStatus[] getAvailableStatuses() {
        return new RoleStatus[]{ACTIVE};
    }

    /**
     * 获取不可用状态列表
     * @return 不可用状态数组
     */
    public static RoleStatus[] getUnavailableStatuses() {
        return new RoleStatus[]{DISABLED, LOCKED, EXPIRED, REJECTED, ARCHIVED};
    }

    /**
     * 获取临时状态列表（临时性状态）
     * @return 临时状态数组
     */
    public static RoleStatus[] getTemporaryStatuses() {
        return new RoleStatus[]{PENDING, DRAFT};
    }

    /**
     * 获取永久状态列表（相对稳定的状态）
     * @return 永久状态数组
     */
    public static RoleStatus[] getPermanentStatuses() {
        return new RoleStatus[]{ACTIVE, DISABLED, LOCKED, EXPIRED, REJECTED, ARCHIVED};
    }

    /**
     * 是否为激活状态
     * @return 是否激活
     */
    public boolean isActive() {
        return this == ACTIVE;
    }

    /**
     * 是否为禁用状态
     * @return 是否禁用
     */
    public boolean isDisabled() {
        return this == DISABLED;
    }

    /**
     * 是否为锁定状态
     * @return 是否锁定
     */
    public boolean isLocked() {
        return this == LOCKED;
    }

    /**
     * 是否为过期状态
     * @return 是否过期
     */
    public boolean isExpired() {
        return this == EXPIRED;
    }

    /**
     * 是否为待审核状态
     * @return 是否待审核
     */
    public boolean isPending() {
        return this == PENDING;
    }

    /**
     * 是否为审核拒绝状态
     * @return 是否审核拒绝
     */
    public boolean isRejected() {
        return this == REJECTED;
    }

    /**
     * 是否为草稿状态
     * @return 是否草稿
     */
    public boolean isDraft() {
        return this == DRAFT;
    }

    /**
     * 是否为归档状态
     * @return 是否归档
     */
    public boolean isArchived() {
        return this == ARCHIVED;
    }

    /**
     * 是否可用（可以正常使用）
     * @return 是否可用
     */
    public boolean isAvailable() {
        return this == ACTIVE;
    }

    /**
     * 是否不可用
     * @return 是否不可用
     */
    public boolean isUnavailable() {
        return !isAvailable();
    }

    /**
     * 是否为临时状态
     * @return 是否临时状态
     */
    public boolean isTemporary() {
        return this == PENDING || this == DRAFT;
    }

    /**
     * 是否为永久状态
     * @return 是否永久状态
     */
    public boolean isPermanent() {
        return !isTemporary();
    }

    /**
     * 是否可以转换到目标状态
     * @param targetStatus 目标状态
     * @return 是否可以转换
     */
    public boolean canTransitionTo(RoleStatus targetStatus) {
        if (targetStatus == null || this == targetStatus) {
            return false;
        }

        switch (this) {
            case ACTIVE:
                // 激活状态可以转换到禁用、锁定、过期、归档
                return targetStatus == DISABLED || targetStatus == LOCKED || 
                       targetStatus == EXPIRED || targetStatus == ARCHIVED;
            
            case DISABLED:
                // 禁用状态可以转换到激活、锁定、归档
                return targetStatus == ACTIVE || targetStatus == LOCKED || targetStatus == ARCHIVED;
            
            case LOCKED:
                // 锁定状态可以转换到激活、禁用、过期、归档
                return targetStatus == ACTIVE || targetStatus == DISABLED || 
                       targetStatus == EXPIRED || targetStatus == ARCHIVED;
            
            case EXPIRED:
                // 过期状态可以转换到激活、禁用、归档
                return targetStatus == ACTIVE || targetStatus == DISABLED || targetStatus == ARCHIVED;
            
            case PENDING:
                // 待审核状态可以转换到激活、拒绝、草稿
                return targetStatus == ACTIVE || targetStatus == REJECTED || targetStatus == DRAFT;
            
            case REJECTED:
                // 拒绝状态可以转换到草稿、待审核
                return targetStatus == DRAFT || targetStatus == PENDING;
            
            case DRAFT:
                // 草稿状态可以转换到待审核、归档
                return targetStatus == PENDING || targetStatus == ARCHIVED;
            
            case ARCHIVED:
                // 归档状态可以转换到激活（恢复）
                return targetStatus == ACTIVE;
            
            default:
                return false;
        }
    }

    /**
     * 获取可转换的目标状态列表
     * @return 可转换的状态数组
     */
    public RoleStatus[] getTransitionableStatuses() {
        switch (this) {
            case ACTIVE:
                return new RoleStatus[]{DISABLED, LOCKED, EXPIRED, ARCHIVED};
            case DISABLED:
                return new RoleStatus[]{ACTIVE, LOCKED, ARCHIVED};
            case LOCKED:
                return new RoleStatus[]{ACTIVE, DISABLED, EXPIRED, ARCHIVED};
            case EXPIRED:
                return new RoleStatus[]{ACTIVE, DISABLED, ARCHIVED};
            case PENDING:
                return new RoleStatus[]{ACTIVE, REJECTED, DRAFT};
            case REJECTED:
                return new RoleStatus[]{DRAFT, PENDING};
            case DRAFT:
                return new RoleStatus[]{PENDING, ARCHIVED};
            case ARCHIVED:
                return new RoleStatus[]{ACTIVE};
            default:
                return new RoleStatus[0];
        }
    }

    /**
     * 获取状态优先级（数值越小优先级越高）
     * @return 优先级数值
     */
    public int getPriority() {
        switch (this) {
            case ACTIVE:
                return 1;
            case PENDING:
                return 2;
            case DRAFT:
                return 3;
            case DISABLED:
                return 4;
            case LOCKED:
                return 5;
            case EXPIRED:
                return 6;
            case REJECTED:
                return 7;
            case ARCHIVED:
                return 8;
            default:
                return 9;
        }
    }

    /**
     * 获取状态颜色（用于前端显示）
     * @return 颜色代码
     */
    public String getColor() {
        switch (this) {
            case ACTIVE:
                return "#52c41a"; // 绿色
            case DISABLED:
                return "#ff4d4f"; // 红色
            case LOCKED:
                return "#fa8c16"; // 橙色
            case EXPIRED:
                return "#faad14"; // 黄色
            case PENDING:
                return "#1890ff"; // 蓝色
            case REJECTED:
                return "#f5222d"; // 深红色
            case DRAFT:
                return "#722ed1"; // 紫色
            case ARCHIVED:
                return "#8c8c8c"; // 灰色
            default:
                return "#d9d9d9"; // 默认灰色
        }
    }

    /**
     * 获取状态图标（用于前端显示）
     * @return 图标名称
     */
    public String getIcon() {
        switch (this) {
            case ACTIVE:
                return "check-circle";
            case DISABLED:
                return "stop";
            case LOCKED:
                return "lock";
            case EXPIRED:
                return "clock-circle";
            case PENDING:
                return "sync";
            case REJECTED:
                return "close-circle";
            case DRAFT:
                return "edit";
            case ARCHIVED:
                return "inbox";
            default:
                return "question-circle";
        }
    }

    /**
     * 获取状态标签类型（用于前端显示）
     * @return 标签类型
     */
    public String getTagType() {
        switch (this) {
            case ACTIVE:
                return "success";
            case DISABLED:
                return "error";
            case LOCKED:
                return "warning";
            case EXPIRED:
                return "warning";
            case PENDING:
                return "processing";
            case REJECTED:
                return "error";
            case DRAFT:
                return "default";
            case ARCHIVED:
                return "default";
            default:
                return "default";
        }
    }

    /**
     * 获取完整显示文本
     * @return 显示文本
     */
    public String getDisplayText() {
        return this.name + "(" + this.code + ")";
    }

    /**
     * 获取简短显示文本
     * @return 简短显示文本
     */
    public String getShortDisplayText() {
        return this.name;
    }

    /**
     * 获取详细显示文本
     * @return 详细显示文本
     */
    public String getDetailDisplayText() {
        return this.name + "(" + this.code + ") - " + this.description;
    }

    @Override
    public String toString() {
        return this.code;
    }
}